115 research outputs found
Confluence Detection for Transformations of Labelled Transition Systems
The development of complex component software systems can be made more
manageable by first creating an abstract model and then incrementally adding
details. Model transformation is an approach to add such details in a
controlled way. In order for model transformation systems to be useful, it is
crucial that they are confluent, i.e. that when applied on a given model, they
will always produce a unique output model, independent of the order in which
rules of the system are applied on the input. In this work, we consider
Labelled Transition Systems (LTSs) to reason about the semantics of models, and
LTS transformation systems to reason about model transformations. In related
work, the problem of confluence detection has been investigated for general
graph structures. We observe, however, that confluence can be detected more
efficiently in special cases where the graphs have particular structural
properties. In this paper, we present a number of observations to detect
confluence of LTS transformation systems, and propose both a new confluence
detection algorithm and a conflict resolution algorithm based on them.Comment: In Proceedings GaM 2015, arXiv:1504.0244
Analysing the Performance of GPU Hash Tables for State Space Exploration
In the past few years, General Purpose Graphics Processors (GPUs) have been
used to significantly speed up numerous applications. One of the areas in which
GPUs have recently led to a significant speed-up is model checking. In model
checking, state spaces, i.e., large directed graphs, are explored to verify
whether models satisfy desirable properties. GPUexplore is a GPU-based model
checker that uses a hash table to efficiently keep track of already explored
states. As a large number of states is discovered and stored during such an
exploration, the hash table should be able to quickly handle many inserts and
queries concurrently. In this paper, we experimentally compare two different
hash tables optimised for the GPU, one being the GPUexplore hash table, and the
other using Cuckoo hashing. We compare the performance of both hash tables
using random and non-random data obtained from model checking experiments, to
analyse the applicability of the two hash tables for state space exploration.
We conclude that Cuckoo hashing is three times faster than GPUexplore hashing
for random data, and that Cuckoo hashing is five to nine times faster for
non-random data. This suggests great potential to further speed up GPUexplore
in the near future.Comment: In Proceedings GaM 2017, arXiv:1712.0834
On the Scalability of the GPUexplore Explicit-State Model Checker
The use of graphics processors (GPUs) is a promising approach to speed up
model checking to such an extent that it becomes feasible to instantly verify
software systems during development. GPUexplore is an explicit-state model
checker that runs all its computations on the GPU. Over the years it has been
extended with various techniques, and the possibilities to further improve its
performance have been continuously investigated. In this paper, we discuss how
the hash table of the tool works, which is at the heart of its functionality.
We propose an alteration of the hash table that in isolated experiments seems
promising, and analyse its effect when integrated in the tool. Furthermore, we
investigate the current scalability of GPUexplore, by experimenting both with
input models of varying sizes and running the tool on one of the latest GPUs of
NVIDIA.Comment: In Proceedings GaM 2017, arXiv:1712.0834
Efficient On-the-Fly Computation of Weak Tau-Confluence
The notion of tau-confluence provides a form of partial order reduction of Labelled Transition Systems (LTSs), by allowing to identify the tau-transitions whose execution does not alter the observable behaviour of the system. Several forms of tau-confluence adequate with branching bisimulation were studied in the literature, ranging from strong to weak ones according to the length of tau-transition sequences considered. Weak tau-confluence is more complex to compute than strong tau-confluence, but provides better LTS reductions. In this report, we aim at devising an efficient detection of weak tau-confluent transitions during an on-the-fly exploration of LTSs. To this purpose, we define and prove new encodings of several weak tau-confluence variants using alternation-free boolean equation systems (BESs), and we apply efficient local BES resolution algorithms to perform the detection. The resulting reduction module, developed within the CADP toolbox using the generic OPEN/CAESAR environment for LTS exploration, was experimented on numerous examples of large LTSs underlying communication protocols and distributed systems. These experiments assessed the efficiency of the reduction and allowed us to identify the best variants of weak tau-confluence that are useful in practice
Sequential and distributed on-the-fly computation of weak tau-confluence
International audienceThe notion of tau-confluence provides a form of partial order reduction of Labelled Transition Systems (LTSs), by enabling to identify the tau-transitions whose execution does not alter the observable behaviour of the system. Several forms of tau-confluence adequate with branching bisimulation were studied in the literature, ranging from strong to weak forms according to the length of tau-transition sequences considered. Weak tau-confluence is more complex to compute than strong tau-confluence, but provides better LTS reductions. In this paper, we aim at devising an efficient detection of weak tau-confluent transitions during an on-the-fly exploration of LTSs. With this purpose, we define and prove new encodings of several weak tau-confluence variants using alternation-free Boolean equation systems (BESs), and we apply efficient local BES resolution algorithms to perform the detection. The resulting reduction module, developed within the CADP toolbox using the generic Open/Cæsar environment for LTS exploration, was tested in both a sequential and a distributed setting on numerous examples of large LTSs underpinning communication protocols and distributed systems. These experiments assessed the efficiency of the reduction and enabled us to identify the best variants of weak tau-confluence that are useful in practice
Solving scheduling problems by untimed model checking
In this paper, we show how scheduling problems can be modelled in untimed process algebra, by using special tick actions. A minimal-time trace leading to a particular action, is one that minimizes the number of tick steps. As a result, we can use any (timed or untimed) model checking tool to find shortest schedules. Instantiating this scheme t
Term Rewriting on GPUs
We present a way to implement term rewriting on a GPU. We do this by letting
the GPU repeatedly perform a massively parallel evaluation of all subterms. We
find that if the term rewrite systems exhibit sufficient internal parallelism,
GPU rewriting substantially outperforms the CPU. Since we expect that our
implementation can be further optimized, and because in any case GPUs will
become much more powerful in the future, this suggests that GPUs are an
interesting platform for term rewriting. As term rewriting can be viewed as a
universal programming language, this also opens a route towards programming
GPUs by term rewriting, especially for irregular computations
Survey on Directed Model Checking
International audienceThis article surveys and gives historical accounts to the algorithmic essentials of directed model checking, a promising bug-hunting technique to mitigate the state explosion problem. In the enumeration process, successor selection is prioritized. We discuss existing guidance and methods to automatically generate them by exploiting system abstractions. We extend the algorithms to feature partial-order reduction and show how liveness problems can be adapted by lifting the search Space. For deterministic, finite domains we instantiate the algorithms to directed symbolic, external and distributed search. For real-time domains we discuss the adaption of the algorithms to timed automata and for probabilistic domains we show the application to counterexample generation. Last but not least, we explain how directed model checking helps to accelerate finding solutions to scheduling problems
- …